home *** CD-ROM | disk | FTP | other *** search
/ The Atari Compendium / The Atari Compendium (Toad Computers) (1994).iso / files / umich / music / eked-m1.zoo / src / load.c < prev    next >
C/C++ Source or Header  |  1995-02-19  |  8KB  |  283 lines
  1. /*
  2.  *  EKED-M1 : Editor for Korg M1 synth; load.c : load/save/print routines
  3.  *  Copyright (C) 1995 Steven M. Eker (Steven.Eker@brunel.ac.uk)
  4.  *
  5.  *  This program is free software; you can redistribute it and/or modify
  6.  *  it under the terms of the GNU General Public License as published by
  7.  *  the Free Software Foundation; either version 2 of the License, or
  8.  *  (at your option) any later version.
  9.  *
  10.  *  This program is distributed in the hope that it will be useful,
  11.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13.  *  GNU General Public License for more details.
  14.  *
  15.  *  You should have received a copy of the GNU General Public License
  16.  *  along with this program; if not, write to the Free Software
  17.  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18.  */
  19.  
  20. #include <stddef.h>
  21. #include <string.h>
  22. #include <stdio.h>
  23. #include <gemfast.h>
  24. #include <aesbind.h>
  25. #include "eked-m1.h"
  26. #include "gm/gem_man.h"
  27. #include "defs.h"
  28. #include "types.h"
  29. #include "midi.h"
  30. #include "externs.h"
  31.  
  32. static FILE *fp;
  33. static BYTE buf[AD_SIZE];
  34.  
  35. static BOOL find_pat(int pat[], int size);
  36. static int print_names(BYTE *data, int size, int one);
  37.  
  38. void load_bank(BANK *bank)
  39. {
  40.   static int header[] = {SYSEX, KORG_ID, FORMAT_ID, M1_ID};
  41.   char *name = fm_file_select("LOAD BANK", "*.BNK", "");
  42.   long size;
  43.   int lseq;
  44.   BOOL glob_change, comb_change, prog_change;
  45.  
  46.   if(!name)
  47.     return;
  48.   BEG_BUSY;
  49.   fp = fopen(name, "rb");
  50.   if(!fp){
  51.     fm_alert(1, OPEN_ALERT);
  52.     END_BUSY;
  53.     return;
  54.   }
  55.   glob_change = comb_change = prog_change = FALSE;
  56.   for(;;){
  57.     if(!find_pat(header, 4))
  58.       break;
  59.     switch(getc(fp)){
  60.     case GLOBAL_DATA_DUMP:
  61.       (void) getc(fp);    /* skip bank flag */
  62.       if(fread(buf, sizeof(char), (size_t) GD_SIZE, fp) !=
  63.          GD_SIZE){
  64.         fm_alert(1, READ_ALERT);
  65.         goto clean_up;
  66.       }
  67.       korg2byte(bank->data, buf, GLOBAL_SIZE);
  68.       glob_change = TRUE;
  69.       break;
  70.     case ALL_COMB_DUMP:
  71.       lseq = getc(fp) & 2;
  72.       size = lseq ? CD50_SIZE : CD_SIZE;
  73.       if(fread(buf, sizeof(char), (size_t) size, fp) != size){
  74.         fm_alert(1, READ_ALERT);
  75.         goto clean_up;
  76.       }
  77.       korg2byte(bank->data + GLOBAL_SIZE, buf,
  78.                 lseq ? (50 * COMBINATION_SIZE) :(100 * COMBINATION_SIZE));
  79.       comb_change = TRUE;
  80.       break;
  81.     case ALL_PROG_DUMP:
  82.       lseq = getc(fp) & 2;
  83.       size = lseq ? PD50_SIZE : PD_SIZE;
  84.       if(fread(buf, sizeof(char), (size_t) size, fp) != size){
  85.         fm_alert(1, READ_ALERT);
  86.         goto clean_up;
  87.       }
  88.       korg2byte(bank->data + PROGRAM_OFFSET, buf,
  89.                 lseq ? (50 * PROGRAM_SIZE) : (100 * PROGRAM_SIZE));
  90.       prog_change = TRUE;
  91.       break;
  92.     case ALL_DATA_DUMP:
  93.       lseq = getc(fp) & 2;
  94.       size = lseq ? AD50_SIZE : AD_SIZE;
  95.       (void) getc(fp); (void) getc(fp);    /* skip seq data size */
  96.       if(fread(buf, sizeof(char), (size_t) size, fp) != size){
  97.         fm_alert(1, READ_ALERT);
  98.         goto clean_up;
  99.       }
  100.       if(lseq){
  101.         korg2byte(buf, buf,    /* in place conversion */
  102.                   (GLOBAL_SIZE + 50 * (COMBINATION_SIZE + PROGRAM_SIZE)));
  103.     memcpy(bank->data, buf,
  104.                (size_t) (GLOBAL_SIZE + 50 * COMBINATION_SIZE));
  105.     memcpy(bank->data + PROGRAM_OFFSET,
  106.                buf + (GLOBAL_SIZE + 50 * COMBINATION_SIZE),
  107.                50 * PROGRAM_SIZE);
  108.       }
  109.       else{
  110.         korg2byte(bank->data, buf,
  111.                   (GLOBAL_SIZE + 100 * (COMBINATION_SIZE + PROGRAM_SIZE)));
  112.       }
  113.       glob_change = comb_change = prog_change = TRUE;
  114.       break;
  115.     }
  116.   }
  117. clean_up:
  118.   fclose(fp);
  119.   strcpy(bank->filename, name);
  120.   END_BUSY;
  121.   if(comb_change && bank->comb_win != 0)
  122.     wm_update(bank->comb_win);
  123.   if(prog_change && bank->prog_win != 0)
  124.     wm_update(bank->prog_win);
  125. }
  126.  
  127. static BOOL find_pat(int pat[], int size)
  128. {
  129.   int c, i = 0;
  130.  
  131.   for(;;){
  132.     c = getc(fp);
  133.     if(c == EOF)
  134.       return FALSE;
  135.     if(c == pat[i]){
  136.       i++;
  137.       if(i == size)
  138.         break;
  139.     }
  140.     else
  141.       i = (c == pat[0]) ? 1 : 0;
  142.   }
  143.   return TRUE;
  144. }
  145.  
  146. void save_bank(BANK *bank, int fsel)
  147. {
  148.   static char header[] = {SYSEX, KORG_ID, FORMAT_ID, M1_ID};
  149.   char *name;
  150.  
  151.   if(fsel || bank->filename[0] == '\0'){
  152.     name = fm_file_select("SAVE BANK", "*.BNK", bank->filename);
  153.     if(!name)
  154.       return;
  155.   }
  156.   else
  157.     name = bank->filename;
  158.   BEG_BUSY;
  159.   fp = fopen(name, "wb");
  160.   if(!fp){
  161.     fm_alert(1, OPEN_ALERT);
  162.     END_BUSY;
  163.     return;
  164.   }
  165.   if(!iszero(bank->data, (size_t) GLOBAL_SIZE)){
  166.     byte2korg(buf, bank->data, GLOBAL_SIZE);
  167.     fwrite(header, sizeof(char), (size_t) 4, fp);
  168.     putc(GLOBAL_DATA_DUMP, fp);
  169.     putc(0x0, fp);
  170.     fwrite(buf, sizeof(char), (size_t) GD_SIZE, fp);
  171.     if(putc(EOX, fp) == EOF){
  172.       fm_alert(1, WRITE_ALERT);
  173.       goto clean_up;
  174.     }
  175.   }
  176.   if(!iszero(bank->data + GLOBAL_SIZE, (size_t) (100 * COMBINATION_SIZE))){
  177.     byte2korg(buf, bank->data + GLOBAL_SIZE, 100 * COMBINATION_SIZE);
  178.     fwrite(header, sizeof(char), (size_t) 4, fp);
  179.     putc(ALL_COMB_DUMP, fp);
  180.     putc(0x0, fp);
  181.     fwrite(buf, sizeof(char), (size_t) CD_SIZE, fp);
  182.     if(putc(EOX, fp) == EOF){
  183.       fm_alert(1, WRITE_ALERT);
  184.       goto clean_up;
  185.     }
  186.   }
  187.   if(!iszero(bank->data + PROGRAM_OFFSET, (size_t) (100 * PROGRAM_SIZE))){
  188.     byte2korg(buf, bank->data + PROGRAM_OFFSET, 100 * PROGRAM_SIZE);
  189.     fwrite(header, sizeof(char), (size_t) 4, fp);
  190.     putc(ALL_PROG_DUMP, fp);
  191.     putc(0x0, fp);
  192.     fwrite(buf, sizeof(char), (size_t) PD_SIZE, fp);
  193.     if(putc(EOX, fp) == EOF){
  194.       fm_alert(1, WRITE_ALERT);
  195.       goto clean_up;
  196.     }
  197.   }
  198. clean_up:
  199.   fclose(fp);
  200.   if(name != bank->filename)
  201.     strcpy(bank->filename, name);
  202.   END_BUSY;
  203. }
  204.  
  205. void print_bank(BANK *bank, int n, char *name, int flags)
  206. {
  207.   static char filename[FILE_SPEC_SIZE];
  208.   int t;
  209.   char *b, *d;
  210.   BOOL print_comb;
  211.  
  212.   if(!name){
  213.     strcpy(filename, bank->filename);
  214.     d = strrchr(filename, '.');
  215.     if(d != NULL && ((b = strrchr(filename, '\\')) == NULL || b < d))
  216.       strcpy(d + 1, "TXT");
  217.     else
  218.       strcat(filename, ".TXT");
  219.     name = fm_file_select("PRINT BANK", "*.TXT", filename);
  220.     if(!name)
  221.       return;
  222.   }
  223.   BEG_BUSY;
  224.   fp = fopen(name, "w");
  225.   if(!fp){
  226.     fm_alert(1, OPEN_ALERT);
  227.     END_BUSY;
  228.     return;
  229.   }
  230.   print_comb = (flags & TX_COMB) &&
  231.     !iszero(bank->data + GLOBAL_SIZE, (size_t) (100 * COMBINATION_SIZE));
  232.   if(print_comb){
  233.     fprintf(fp, "<<< BANK %d (%s) COMBINATIONS >>>\n", n, bank->filename);
  234.     t = print_names(bank->data + GLOBAL_SIZE,
  235.                     COMBINATION_SIZE, flags & TX_ONE);
  236.     if(t < 0){
  237.       fm_alert(1, WRITE_ALERT);
  238.       goto clean_up;
  239.     }
  240.   }
  241.   if((flags & TX_PROG) &&
  242.      !iszero(bank->data + PROGRAM_OFFSET, (size_t) (100 * PROGRAM_SIZE))){
  243.     if(print_comb)
  244.       putc('\n', fp);
  245.     fprintf(fp, "<<< BANK %d (%s) PROGRAMS >>>\n", n, bank->filename);
  246.     t = print_names(bank->data + PROGRAM_OFFSET, PROGRAM_SIZE, flags & TX_ONE);
  247.     if(t < 0){
  248.       fm_alert(1, WRITE_ALERT);
  249.       goto clean_up;
  250.     }
  251.   }
  252. clean_up:
  253.   fclose(fp);
  254.   END_BUSY;
  255. }
  256.  
  257. static int print_names(BYTE *data, int size, int one)
  258. {
  259.   static char buf[11];
  260.   int i, j, t;
  261.  
  262.   if(one){
  263.     for(i = 0; i <= 99; i++){
  264.       korg2str(buf, data, (size_t) 10);
  265.       t = fprintf(fp, "%02d %s\n", i, buf);
  266.       if(t < 0)
  267.         return t;
  268.       data += size;
  269.     }
  270.   }
  271.   else{
  272.     for(i = 0; i <= 19; i++){
  273.       for(j = 0; j <= 80; j += 20){
  274.         korg2str(buf, data + (i + j) * size, (size_t) 10);
  275.         t = fprintf(fp, "%02d %s%c", i + j, buf, (j == 80 ? '\n' : '\t'));
  276.         if(t < 0)
  277.           return t;
  278.       }
  279.     }
  280.   }
  281.   return 0;
  282. }
  283.